{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: graphviz in c:\\users\\12309\\appdata\\roaming\\python\\python311\\site-packages (0.20.3)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install graphviz -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: scikit-learn in c:\\programdata\\anaconda3\\lib\\site-packages (1.2.2)\n",
      "Requirement already satisfied: numpy>=1.17.3 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.24.3)\n",
      "Requirement already satisfied: scipy>=1.3.2 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.10.1)\n",
      "Requirement already satisfied: joblib>=1.1.1 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.2.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (2.2.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install scikit-learn -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data =pd.DataFrame (datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris =load_iris () #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0.9, 'x[0] <= 5.45\\ngini = 0.5\\nsamples = 70\\nvalue = [36, 34]'),\n",
       " Text(0.25, 0.7, 'x[1] <= 2.65\\ngini = 0.108\\nsamples = 35\\nvalue = [33, 2]'),\n",
       " Text(0.125, 0.5, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.375, 0.5, 'x[0] <= 5.35\\ngini = 0.057\\nsamples = 34\\nvalue = [33, 1]'),\n",
       " Text(0.25, 0.3, 'gini = 0.0\\nsamples = 30\\nvalue = [30, 0]'),\n",
       " Text(0.5, 0.3, 'x[1] <= 3.35\\ngini = 0.375\\nsamples = 4\\nvalue = [3, 1]'),\n",
       " Text(0.375, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.625, 0.1, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]'),\n",
       " Text(0.75, 0.7, 'x[1] <= 3.7\\ngini = 0.157\\nsamples = 35\\nvalue = [3, 32]'),\n",
       " Text(0.625, 0.5, 'gini = 0.0\\nsamples = 32\\nvalue = [0, 32]'),\n",
       " Text(0.875, 0.5, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "ExecutableNotFound",
     "evalue": "failed to execute WindowsPath('dot'), make sure the Graphviz executables are on your systems' PATH",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\backend\\execute.py:76\u001b[0m, in \u001b[0;36mrun_check\u001b[1;34m(cmd, input_lines, encoding, quiet, **kwargs)\u001b[0m\n\u001b[0;32m     75\u001b[0m         kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstdout\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstderr\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m subprocess\u001b[38;5;241m.\u001b[39mPIPE\n\u001b[1;32m---> 76\u001b[0m     proc \u001b[38;5;241m=\u001b[39m _run_input_lines(cmd, input_lines, kwargs\u001b[38;5;241m=\u001b[39mkwargs)\n\u001b[0;32m     77\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\backend\\execute.py:96\u001b[0m, in \u001b[0;36m_run_input_lines\u001b[1;34m(cmd, input_lines, kwargs)\u001b[0m\n\u001b[0;32m     95\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_run_input_lines\u001b[39m(cmd, input_lines, \u001b[38;5;241m*\u001b[39m, kwargs):\n\u001b[1;32m---> 96\u001b[0m     popen \u001b[38;5;241m=\u001b[39m subprocess\u001b[38;5;241m.\u001b[39mPopen(cmd, stdin\u001b[38;5;241m=\u001b[39msubprocess\u001b[38;5;241m.\u001b[39mPIPE, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m     98\u001b[0m     stdin_write \u001b[38;5;241m=\u001b[39m popen\u001b[38;5;241m.\u001b[39mstdin\u001b[38;5;241m.\u001b[39mwrite\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\subprocess.py:1024\u001b[0m, in \u001b[0;36mPopen.__init__\u001b[1;34m(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags, restore_signals, start_new_session, pass_fds, user, group, extra_groups, encoding, errors, text, umask, pipesize, process_group)\u001b[0m\n\u001b[0;32m   1021\u001b[0m             \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr \u001b[38;5;241m=\u001b[39m io\u001b[38;5;241m.\u001b[39mTextIOWrapper(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr,\n\u001b[0;32m   1022\u001b[0m                     encoding\u001b[38;5;241m=\u001b[39mencoding, errors\u001b[38;5;241m=\u001b[39merrors)\n\u001b[1;32m-> 1024\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_execute_child(args, executable, preexec_fn, close_fds,\n\u001b[0;32m   1025\u001b[0m                         pass_fds, cwd, env,\n\u001b[0;32m   1026\u001b[0m                         startupinfo, creationflags, shell,\n\u001b[0;32m   1027\u001b[0m                         p2cread, p2cwrite,\n\u001b[0;32m   1028\u001b[0m                         c2pread, c2pwrite,\n\u001b[0;32m   1029\u001b[0m                         errread, errwrite,\n\u001b[0;32m   1030\u001b[0m                         restore_signals,\n\u001b[0;32m   1031\u001b[0m                         gid, gids, uid, umask,\n\u001b[0;32m   1032\u001b[0m                         start_new_session, process_group)\n\u001b[0;32m   1033\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m:\n\u001b[0;32m   1034\u001b[0m     \u001b[38;5;66;03m# Cleanup if the child failed starting.\u001b[39;00m\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\subprocess.py:1509\u001b[0m, in \u001b[0;36mPopen._execute_child\u001b[1;34m(self, args, executable, preexec_fn, close_fds, pass_fds, cwd, env, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, unused_restore_signals, unused_gid, unused_gids, unused_uid, unused_umask, unused_start_new_session, unused_process_group)\u001b[0m\n\u001b[0;32m   1508\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1509\u001b[0m     hp, ht, pid, tid \u001b[38;5;241m=\u001b[39m _winapi\u001b[38;5;241m.\u001b[39mCreateProcess(executable, args,\n\u001b[0;32m   1510\u001b[0m                              \u001b[38;5;66;03m# no special security\u001b[39;00m\n\u001b[0;32m   1511\u001b[0m                              \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m   1512\u001b[0m                              \u001b[38;5;28mint\u001b[39m(\u001b[38;5;129;01mnot\u001b[39;00m close_fds),\n\u001b[0;32m   1513\u001b[0m                              creationflags,\n\u001b[0;32m   1514\u001b[0m                              env,\n\u001b[0;32m   1515\u001b[0m                              cwd,\n\u001b[0;32m   1516\u001b[0m                              startupinfo)\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m   1518\u001b[0m     \u001b[38;5;66;03m# Child is launched. Close the parent's copy of those pipe\u001b[39;00m\n\u001b[0;32m   1519\u001b[0m     \u001b[38;5;66;03m# handles that only the child should have open.  You need\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1522\u001b[0m     \u001b[38;5;66;03m# pipe will not close when the child process exits and the\u001b[39;00m\n\u001b[0;32m   1523\u001b[0m     \u001b[38;5;66;03m# ReadFile will hang.\u001b[39;00m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 2] 系统找不到指定的文件。",
      "\nThe above exception was the direct cause of the following exception:\n",
      "\u001b[1;31mExecutableNotFound\u001b[0m                        Traceback (most recent call last)",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\IPython\\core\\formatters.py:974\u001b[0m, in \u001b[0;36mMimeBundleFormatter.__call__\u001b[1;34m(self, obj, include, exclude)\u001b[0m\n\u001b[0;32m    971\u001b[0m     method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n\u001b[0;32m    973\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 974\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m method(include\u001b[38;5;241m=\u001b[39minclude, exclude\u001b[38;5;241m=\u001b[39mexclude)\n\u001b[0;32m    975\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m    976\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\jupyter_integration.py:98\u001b[0m, in \u001b[0;36mJupyterIntegration._repr_mimebundle_\u001b[1;34m(self, include, exclude, **_)\u001b[0m\n\u001b[0;32m     96\u001b[0m include \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(include) \u001b[38;5;28;01mif\u001b[39;00m include \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jupyter_mimetype}\n\u001b[0;32m     97\u001b[0m include \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(exclude \u001b[38;5;129;01mor\u001b[39;00m [])\n\u001b[1;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {mimetype: \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, method_name)()\n\u001b[0;32m     99\u001b[0m         \u001b[38;5;28;01mfor\u001b[39;00m mimetype, method_name \u001b[38;5;129;01min\u001b[39;00m MIME_TYPES\u001b[38;5;241m.\u001b[39mitems()\n\u001b[0;32m    100\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m mimetype \u001b[38;5;129;01min\u001b[39;00m include}\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\jupyter_integration.py:98\u001b[0m, in \u001b[0;36m<dictcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     96\u001b[0m include \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(include) \u001b[38;5;28;01mif\u001b[39;00m include \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m {\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jupyter_mimetype}\n\u001b[0;32m     97\u001b[0m include \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(exclude \u001b[38;5;129;01mor\u001b[39;00m [])\n\u001b[1;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {mimetype: \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, method_name)()\n\u001b[0;32m     99\u001b[0m         \u001b[38;5;28;01mfor\u001b[39;00m mimetype, method_name \u001b[38;5;129;01min\u001b[39;00m MIME_TYPES\u001b[38;5;241m.\u001b[39mitems()\n\u001b[0;32m    100\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m mimetype \u001b[38;5;129;01min\u001b[39;00m include}\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\jupyter_integration.py:112\u001b[0m, in \u001b[0;36mJupyterIntegration._repr_image_svg_xml\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    110\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_repr_image_svg_xml\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mstr\u001b[39m:\n\u001b[0;32m    111\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Return the rendered graph as SVG string.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 112\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpipe(\u001b[38;5;28mformat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msvg\u001b[39m\u001b[38;5;124m'\u001b[39m, encoding\u001b[38;5;241m=\u001b[39mSVG_ENCODING)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\piping.py:104\u001b[0m, in \u001b[0;36mPipe.pipe\u001b[1;34m(self, format, renderer, formatter, neato_no_op, quiet, engine, encoding)\u001b[0m\n\u001b[0;32m     55\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpipe\u001b[39m(\u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m     56\u001b[0m          \u001b[38;5;28mformat\u001b[39m: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m     57\u001b[0m          renderer: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     61\u001b[0m          engine: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m     62\u001b[0m          encoding: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m typing\u001b[38;5;241m.\u001b[39mUnion[\u001b[38;5;28mbytes\u001b[39m, \u001b[38;5;28mstr\u001b[39m]:\n\u001b[0;32m     63\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Return the source piped through the Graphviz layout command.\u001b[39;00m\n\u001b[0;32m     64\u001b[0m \n\u001b[0;32m     65\u001b[0m \u001b[38;5;124;03m    Args:\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    102\u001b[0m \u001b[38;5;124;03m        '<?xml version='\u001b[39;00m\n\u001b[0;32m    103\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 104\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipe_legacy(\u001b[38;5;28mformat\u001b[39m,\n\u001b[0;32m    105\u001b[0m                              renderer\u001b[38;5;241m=\u001b[39mrenderer,\n\u001b[0;32m    106\u001b[0m                              formatter\u001b[38;5;241m=\u001b[39mformatter,\n\u001b[0;32m    107\u001b[0m                              neato_no_op\u001b[38;5;241m=\u001b[39mneato_no_op,\n\u001b[0;32m    108\u001b[0m                              quiet\u001b[38;5;241m=\u001b[39mquiet,\n\u001b[0;32m    109\u001b[0m                              engine\u001b[38;5;241m=\u001b[39mengine,\n\u001b[0;32m    110\u001b[0m                              encoding\u001b[38;5;241m=\u001b[39mencoding)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\_tools.py:171\u001b[0m, in \u001b[0;36mdeprecate_positional_args.<locals>.decorator.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    162\u001b[0m     wanted \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvalue\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m    163\u001b[0m                        \u001b[38;5;28;01mfor\u001b[39;00m name, value \u001b[38;5;129;01min\u001b[39;00m deprecated\u001b[38;5;241m.\u001b[39mitems())\n\u001b[0;32m    164\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mThe signature of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m will be reduced\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m    165\u001b[0m                   \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msupported_number\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m positional args\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m    166\u001b[0m                   \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlist\u001b[39m(supported)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: pass \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mwanted\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m    167\u001b[0m                   \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m as keyword arg(s)\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m    168\u001b[0m                   stacklevel\u001b[38;5;241m=\u001b[39mstacklevel,\n\u001b[0;32m    169\u001b[0m                   category\u001b[38;5;241m=\u001b[39mcategory)\n\u001b[1;32m--> 171\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\piping.py:121\u001b[0m, in \u001b[0;36mPipe._pipe_legacy\u001b[1;34m(self, format, renderer, formatter, neato_no_op, quiet, engine, encoding)\u001b[0m\n\u001b[0;32m    112\u001b[0m \u001b[38;5;129m@_tools\u001b[39m\u001b[38;5;241m.\u001b[39mdeprecate_positional_args(supported_number\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m    113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_pipe_legacy\u001b[39m(\u001b[38;5;28mself\u001b[39m,\n\u001b[0;32m    114\u001b[0m                  \u001b[38;5;28mformat\u001b[39m: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    119\u001b[0m                  engine: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m    120\u001b[0m                  encoding: typing\u001b[38;5;241m.\u001b[39mOptional[\u001b[38;5;28mstr\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m typing\u001b[38;5;241m.\u001b[39mUnion[\u001b[38;5;28mbytes\u001b[39m, \u001b[38;5;28mstr\u001b[39m]:\n\u001b[1;32m--> 121\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipe_future(\u001b[38;5;28mformat\u001b[39m,\n\u001b[0;32m    122\u001b[0m                              renderer\u001b[38;5;241m=\u001b[39mrenderer,\n\u001b[0;32m    123\u001b[0m                              formatter\u001b[38;5;241m=\u001b[39mformatter,\n\u001b[0;32m    124\u001b[0m                              neato_no_op\u001b[38;5;241m=\u001b[39mneato_no_op,\n\u001b[0;32m    125\u001b[0m                              quiet\u001b[38;5;241m=\u001b[39mquiet,\n\u001b[0;32m    126\u001b[0m                              engine\u001b[38;5;241m=\u001b[39mengine,\n\u001b[0;32m    127\u001b[0m                              encoding\u001b[38;5;241m=\u001b[39mencoding)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\piping.py:149\u001b[0m, in \u001b[0;36mPipe._pipe_future\u001b[1;34m(self, format, renderer, formatter, neato_no_op, quiet, engine, encoding)\u001b[0m\n\u001b[0;32m    146\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m encoding \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m    147\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m codecs\u001b[38;5;241m.\u001b[39mlookup(encoding) \u001b[38;5;129;01mis\u001b[39;00m codecs\u001b[38;5;241m.\u001b[39mlookup(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mencoding):\n\u001b[0;32m    148\u001b[0m         \u001b[38;5;66;03m# common case: both stdin and stdout need the same encoding\u001b[39;00m\n\u001b[1;32m--> 149\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipe_lines_string(\u001b[38;5;241m*\u001b[39margs, encoding\u001b[38;5;241m=\u001b[39mencoding, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    150\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    151\u001b[0m         raw \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pipe_lines(\u001b[38;5;241m*\u001b[39margs, input_encoding\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mencoding, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\backend\\piping.py:212\u001b[0m, in \u001b[0;36mpipe_lines_string\u001b[1;34m(engine, format, input_lines, encoding, renderer, formatter, neato_no_op, quiet)\u001b[0m\n\u001b[0;32m    206\u001b[0m cmd \u001b[38;5;241m=\u001b[39m dot_command\u001b[38;5;241m.\u001b[39mcommand(engine, \u001b[38;5;28mformat\u001b[39m,\n\u001b[0;32m    207\u001b[0m                           renderer\u001b[38;5;241m=\u001b[39mrenderer,\n\u001b[0;32m    208\u001b[0m                           formatter\u001b[38;5;241m=\u001b[39mformatter,\n\u001b[0;32m    209\u001b[0m                           neato_no_op\u001b[38;5;241m=\u001b[39mneato_no_op)\n\u001b[0;32m    210\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput_lines\u001b[39m\u001b[38;5;124m'\u001b[39m: input_lines, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m'\u001b[39m: encoding}\n\u001b[1;32m--> 212\u001b[0m proc \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mrun_check(cmd, capture_output\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, quiet\u001b[38;5;241m=\u001b[39mquiet, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    213\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m proc\u001b[38;5;241m.\u001b[39mstdout\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\graphviz\\backend\\execute.py:81\u001b[0m, in \u001b[0;36mrun_check\u001b[1;34m(cmd, input_lines, encoding, quiet, **kwargs)\u001b[0m\n\u001b[0;32m     79\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m     80\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m e\u001b[38;5;241m.\u001b[39merrno \u001b[38;5;241m==\u001b[39m errno\u001b[38;5;241m.\u001b[39mENOENT:\n\u001b[1;32m---> 81\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m ExecutableNotFound(cmd) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[0;32m     82\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m     84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m quiet \u001b[38;5;129;01mand\u001b[39;00m proc\u001b[38;5;241m.\u001b[39mstderr:\n",
      "\u001b[1;31mExecutableNotFound\u001b[0m: failed to execute WindowsPath('dot'), make sure the Graphviz executables are on your systems' PATH"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<graphviz.sources.Source at 0x298a856a3d0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 50, 'min_impurity_decrease': 0.1, 'min_samples_leaf': 5} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
